package com.hg.api;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONObject;

import com.google.gson.Gson;
import com.hg.cache.FIFOCache;
import com.hg.forSearch.db.dto.ForSearchDTO;
import com.hg.forSearch.service.ForSearchService;
import com.hg.util.common.Common;
import com.hg.util.db.Locale;
import com.hg.util.http.HttpXmlClient;

public class ApiService
{
	public Gson gson = new Gson();
	public HttpXmlClient hxc = new HttpXmlClient();
	
	public String weixin_withdraw_api_url;		//微信提现接口路径
	public String weixinApi_url;				//微信API接口路径
	public String weixin_pay_api_url;			//微信支付接口路径
	public String access_token_api;				//微信获取access_token的路径
	public String remote_api_url;				//远程API的域名
	
	/**
	 * 供给定时器使用
	 * @param remote_api_url
	 */
	public ApiService(String api_url){
		remote_api_url=api_url;
	}
	
	public ApiService(Map root)
	{
		Map<String,String> m_config=getConfig(root);
		if("1".equals(m_config.get("weixin_config_is_user_table").trim())){
			//从数据库里面获取
			weixin_withdraw_api_url=m_config.get("weixin_config_weixin_withdraw_api_url").trim();
			weixinApi_url=m_config.get("weixin_config_weixinApi_url").trim();
			weixin_pay_api_url=m_config.get("weixin_config_weixin_pay_api_url").trim();
			access_token_api=m_config.get("weixin_config_access_token_api").trim();
			
		}else{
			//从配置文件里面获取
			weixin_withdraw_api_url =Locale.DBG.getString("weixin_withdraw_api_url").trim();	
			weixinApi_url =Locale.DBG.getString("weixinApi_url").trim();	
			weixin_pay_api_url =Locale.DBG.getString("weixin_pay_api_url").trim();	
			access_token_api =Locale.DBG.getString("access_token_api").trim();	
		}
		
		//远程API接口
		if("1".equals(m_config.get("weixin_config_is_remote_debug").trim())){
			//从数据库里面获取
			remote_api_url=m_config.get("weixin_config_remote_api_url").trim();
		}else{
			//获取当前项目的路径
			HttpServletRequest request = (HttpServletRequest) root.get("request");
			remote_api_url=Common.getProjectUrl(request);
		}
	}

	/**
	 * 从内存中获取数据库的缓存
	 * @param root
	 * @return
	 */
	public Map<String,String> getConfig(Map root){
		FIFOCache<String, Object> cache = (FIFOCache<String, Object>) root.get("cache");
		Map<String,String> m_config=(Map<String, String>) cache.get("m_config");
		
		if(null==m_config){
			ForSearchService forS = new ForSearchService();
			
			List<ForSearchDTO> list=forS.getAll("hh_base_m_config_search");
			m_config= new HashMap<String,String>();
			for(int i=0;i<list.size();i++){
				ForSearchDTO dto = list.get(i);
				m_config.put(dto.getId(), dto.getName());
			}
			
			cache.put("m_config", m_config);
		}
		
		return m_config;
	}
	
	
	/**
	 * @param root	servlet传递过来的那个Map root对象
	 * @param data	需要返回前端的数据,一般是Map 集合
	 * @throws IOException
	 */
	public void json_return(Map root,Object data){
		HttpServletResponse response = (HttpServletResponse) root.get("response");
		PrintWriter out=null;
		try
		{
			out = response.getWriter();
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		
		out.write(gson.toJson(data));
		out.flush();
		out.close();
	}
	
	/**
	 * @param root	servlet传递过来的那个Map root对象
	 * @param data	需要返回前端的数据,一般是Map 集合
	 * @throws IOException
	 */
	public void js_redirect(Map root,String url){
		HttpServletResponse response = (HttpServletResponse) root.get("response");
		PrintWriter out=null;
		try
		{
			out = response.getWriter();
			out.println("<script>window.location.href='"+url+"';</script>");
			out.flush();
			out.close();
		}
		catch (IOException e)
		{
			e.printStackTrace();
			out.flush();
			out.close();
		}
		
	}
	
	/**
	 * @param app_name
	 * @param url  比如: userCenter/index.do?id=1
	 * @return
	 */
	private String getApiUrl(String app_name,String url){
		if(null==app_name){
			return remote_api_url+"/api/"+url;
		}else{
			return remote_api_url+"/"+app_name+"/"+url;
		}
	}
	
	/**
	 * @param app_name	默认值为weixin
	 * @param url	比如: userCenter/index.do?id=1
	 * @return
	 */
	private String getApiUrl(String url){
		return this.getApiUrl(null, url);
	}
	
	/**
	 * 尽量不要用这个,在此约定:所有能调用的api 的app_name=api
	 * http get方式
	 * @param app_name
	 * @param url
	 * @return
	 */
	public String http_get(String app_name,String url){
		String json_str = hxc.get(this.getApiUrl(app_name, url));
		return json_str;
	}
	public String http_get(String url){
		return this.http_get(null, url);
	}
	
	/**
	 * http post方式
	 * 尽量不要用这个,在此约定:所有能调用的api 的app_name=api
	 * @param app_name
	 * @param url
	 * @return
	 */
	public String http_post(String app_name,String url, Map<String, String> params){
		String json_str = hxc.post(this.getApiUrl(app_name, url),params);
		return json_str;
	}
	public String http_post(String url, Map<String, String> params){
		return this.http_post(null, url,params);
	}
	
	public JSONObject strToJSONObject(String return_json){
		try{
			JSONObject json = JSONObject.fromObject(return_json);
			return json;
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}
		
	}
	
	/**
	 * 是否请求成功
	 * @param return_json
	 * @return
	 */
	public boolean isSuccess(String return_json){
		JSONObject json = this.strToJSONObject(return_json);
		if(null!=json){
			if(-1==json.getInt("err_code")){
				return true;
			}else{
				return false;
			}
		}else{
			return false;
		}
	}
	
	/**
	 * 是否请求成功 专门供给使用后来列表数据的
	 * @param return_json
	 * @return
	 */
	public boolean isSuccessForIndex(String return_json){
		JSONObject json = this.strToJSONObject(return_json);
		if(null!=json){
			if(0<json.getInt("total")){
				return true;
			}else{
				return false;
			}
		}else{
			return false;
		}
	}
	
	/**
	 * 是否请求成功
	 * 所有调用接口没成功,又想事后系统自动执行的,都需要调用此接口
	 * 没添加成功时,添加一条事件到数据库
	 * @param return_json
	 * @return
	 */
	public boolean isSuccess(String return_json,String http_request_mode,String url, Map<String, String> params){
		JSONObject json = this.strToJSONObject(return_json);
		if(null!=json){
			if(-1==json.getInt("err_code")){
				return true;
			}else{
				return false;
			}
		}else{
			return false;
		}
	}
	
	/**
	 * 获取错误码和错误信息
	 * 调用此方法时,最好先调用isSuccess判断是否成功
	 */
	public Map<String, Object> getCodeAndMsg(String return_json){
		Map<String, Object> map = new HashMap<String, Object>();
		JSONObject json = this.strToJSONObject(return_json);
		if(null!=json){
			map.put("err_code", json.getInt("err_code"));
			map.put("err_msg", json.getString("err_msg"));
			return map;
		}else{
			return null;
		}
	}
	
	/**
	 * 调用此方法之前,最好先调用isSuccess判断是否成功
	 * @param return_json
	 * @param key
	 * @return
	 */
	public String getString(String return_json,String key){
		JSONObject json = this.strToJSONObject(return_json);
		return json.getString(key);
	}
	
	/**
	 * 调用此方法之前,最好先调用isSuccess判断是否成功
	 * 针对VO对象
	 * @param return_json
	 * @param key
	 * @return
	 */
	public Map<String,Object> getMap(String return_json,String key){
		JSONObject json = this.strToJSONObject(return_json);
		
		try{
			Map<String,Object> map = gson.fromJson(json.getString(key), Map.class);
			return map;
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}
	}
	

	/**
	 * 调用此方法之前,最好先调用isSuccess判断是否成功
	 * 针对List<VO>的数据
	 * @param return_json
	 * @param key
	 * @return
	 */
	public List<Map<String,Object>> getList(String return_json,String key){
		JSONObject json = this.strToJSONObject(return_json);
		try{
			List<Map<String,Object>> list = gson.fromJson(json.getString(key), List.class);
			for(int i=0;i<list.size();i++){
				Map<String,Object> map = list.get(i);
				//System.out.println(map.get("id"));
			}
			return list;
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}
	}
}
